package com.example.controller.admin;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.lang.Dict;
import com.example.entity.*;
import com.example.service.IBigTypeService;
import com.example.service.IOrderDetailService;
import com.example.service.IOrderService;
import com.example.service.IProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 功能：
 * 作者：zhuang
 * 日期：2024/6/21 10:53
 */

@RestController
@RequestMapping("/admin/charts")
public class AdminChartsController {
    @Autowired
    private IOrderService orderService;

    @Autowired
    private IOrderDetailService orderDetailService;

    @Autowired
    private IProductService productService;
    @Autowired
    private IBigTypeService bigTypeService;
    /**
     * 获取统计图数据
     * @return 动态数据
     */
    @GetMapping("/line")
    public R charts() {
        // 获取所有订单列表
        List<Order> list = orderService.list();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        // 获取订单日期集合并去重
        Set<String> dates = list.stream()
                .map(Order::getCreateDate)
                .map(sdf::format)
                .collect(Collectors.toSet());
        // 将日期进行排序
        List<String> dateList = new ArrayList<>(dates);
        dateList.sort(Comparator.naturalOrder());
        // 生成折线图数据
        List<Dict> lineList = new ArrayList<>();
        for (String date : dateList) {
            BigDecimal sum = list.stream()
                    .filter(order -> sdf.format(order.getCreateDate()).equals(date))
                    .map(Order::getTotalPrice)
                    .reduce(BigDecimal::add)
                    .orElse(BigDecimal.ZERO);
            Dict dict = Dict.create().set("date", date).set("value", sum);
            lineList.add(dict);
        }
        // 获取所有订单详情
        List<OrderDetail> list1 = orderDetailService.list();
        // 获取商品名称集合
        Set<String> goodsNames = list1.stream()
                .map(OrderDetail::getGoodsName)
                .collect(Collectors.toSet());
        // 分别计算健康套餐和普通商品的柱状图数据
        List<Dict> healthBarList = new ArrayList<>();
        List<Dict> normalBarList = new ArrayList<>();
        // 根据商品名称进行分类，分别统计健康套餐和普通商品的总价格和总数量
        for (String name : goodsNames) {
            // 计算健康套餐商品的总价格和总数量
            BigDecimal healthSumPrice = list1.stream()
                    .filter(orderDetail -> "health".equals(orderDetail.getItemType()) && orderDetail.getGoodsName().equals(name))
                    .map(OrderDetail::getGoodsPrice)
                    .reduce(BigDecimal::add)
                    .orElse(BigDecimal.ZERO);
            int healthSumNumber = list1.stream()
                    .filter(orderDetail -> "health".equals(orderDetail.getItemType()) && orderDetail.getGoodsName().equals(name))
                    .mapToInt(OrderDetail::getGoodsNumber)
                    .sum();
            if (healthSumPrice.compareTo(BigDecimal.ZERO) > 0 || healthSumNumber > 0) {
                Dict healthDict = Dict.create();
                healthDict.set("GoodsNames", name)
                        .set("value1", healthSumPrice)  // 总价格
                        .set("value2", healthSumNumber); // 总数量
                healthBarList.add(healthDict);
            }
            // 计算普通商品的总价格和总数量
            BigDecimal normalSumPrice = list1.stream()
                    .filter(orderDetail -> "normal".equals(orderDetail.getItemType()) && orderDetail.getGoodsName().equals(name))
                    .map(OrderDetail::getGoodsPrice)
                    .reduce(BigDecimal::add)
                    .orElse(BigDecimal.ZERO);
            int normalSumNumber = list1.stream()
                    .filter(orderDetail -> "normal".equals(orderDetail.getItemType()) && orderDetail.getGoodsName().equals(name))
                    .mapToInt(OrderDetail::getGoodsNumber)
                    .sum();
            if (normalSumPrice.compareTo(BigDecimal.ZERO) > 0 || normalSumNumber > 0) {
                Dict normalDict = Dict.create();
                normalDict.set("GoodsNames", name)
                        .set("value1", normalSumPrice)  // 总价格
                        .set("value2", normalSumNumber); // 总数量
                normalBarList.add(normalDict);
            }
        }
        // 返回健康套餐、普通商品和折线图数据
        Dict res = Dict.create().set("healthBar", healthBarList)
                .set("normalBar", normalBarList)
                .set("line", lineList);

        return R.ok().put("data", res);
    }


    @GetMapping("/pie")
    public R getPieChart() {
        // 获取所有商品
        List<Product> productList = productService.findAll();

        // 获取所有商品大类
        List<BigType> bigTypes = bigTypeService.findAll();

        List<Dict> pieList = new ArrayList<>();
        List<String> bigTypeNames = new ArrayList<>();  // 存储商品大类名称

        // 遍历每个商品大类
        for (BigType bigType : bigTypes) {
            Dict bigTypeDict = Dict.create();
            bigTypeDict.set("name", bigType.getName());

            // 过滤出当前大类下的商品
            List<Product> productsInBigType = productList.stream()
                    .filter(product -> product.getType() != null
                            && product.getType().getBigType() != null
                            && product.getType().getBigType().getId().equals(bigType.getId())) // 过滤大类下的商品
                    .collect(Collectors.toList());

            System.out.println("productsInBigType====>>> " + productsInBigType);

            // 对于每个大类，生成该类下商品的库存数据
            List<Dict> productDataList = new ArrayList<>();
            int totalStock = 0; // 计算当前大类的库存总和

            for (Product product : productsInBigType) {
                Dict productData = Dict.create();
                productData.set("name", product.getName());  // 商品名称
                productData.set("value", product.getStock());  // 商品库存

                totalStock += product.getStock();  // 累加库存总和
                productDataList.add(productData);  // 加入该商品的库存数据
            }

            // 将大类的数据添加到字典中
            bigTypeDict.set("products", productDataList);  // 存储该大类下商品的所有数据
            bigTypeDict.set("totalStock", totalStock);  // 存储该大类的库存总和

            // 将该大类数据加入 pieList
            pieList.add(bigTypeDict);
            bigTypeNames.add(bigType.getName());  // 存储商品大类名称
        }

        // 输出调试信息
        System.out.println("pieList====>>> " + pieList);
        System.out.println("bigTypeNames====>>> " + bigTypeNames);

        // 返回给前端的所有数据
        Dict res = Dict.create()
                .set("pie", pieList)
                .set("bigTypeNames", bigTypeNames);  // 将大类名称列表一起返回

        return R.ok().put("data", res);
    }

}
